/**
 * 币价格服务
 * 用于获取币的价格信息（单次请求模式）
 */
import { get } from '@/utils/request'

class SpontaneousCoinService {
  constructor() {
    this.requestStatus = new Map() // 存储每个币种的请求状态
    this.retryCount = new Map() // 存储每个币种的重试次数
    this.maxRetries = 3 // 最大重试次数
    this.retryDelay = 2000 // 重试延迟时间（毫秒）
  }

  /**
   * 获取币价格（单次请求）
   * @param {string} symbol 币种符号
   * @param {Function} callback 价格更新回调函数
   * @returns {Promise} 返回Promise对象
   */
  async getSpontaneousCoinPrice(symbol, callback) {
    if (this.requestStatus.get(symbol) === 'loading') {
      console.log(`币种 ${symbol} 请求已在进行中，跳过重复请求`)
      return
    }

    console.log(`开始获取币种 ${symbol} 价格`)
    
    // 设置请求状态
    this.requestStatus.set(symbol, 'loading')
    this.retryCount.set(symbol, 0)
    
    try {
      const result = await this.fetchSpontaneousCoinPrice(symbol, callback)
      this.requestStatus.set(symbol, 'success')
      return result
    } catch (error) {
      console.error(`币种 ${symbol} 价格获取失败:`, error)
      this.requestStatus.set(symbol, 'error')
      await this.handleRequestError(symbol, error, callback)
      throw error
    }
  }

  /**
   * 处理请求错误
   * @param {string} symbol 币种符号
   * @param {Error} error 错误对象
   * @param {Function} callback 回调函数
   */
  async handleRequestError(symbol, error, callback) {
    const currentRetryCount = this.retryCount.get(symbol) || 0
    
    if (currentRetryCount < this.maxRetries) {
      // 增加重试次数
      this.retryCount.set(symbol, currentRetryCount + 1)
      console.log(`币种 ${symbol} 第 ${currentRetryCount + 1} 次重试，${this.retryDelay}ms 后重试`)
      
      // 延迟后重试
      setTimeout(async () => {
        try {
          await this.fetchSpontaneousCoinPrice(symbol, callback)
          // 重试成功，重置重试次数和状态
          this.retryCount.set(symbol, 0)
          this.requestStatus.set(symbol, 'success')
        } catch (retryError) {
          console.error(`币种 ${symbol} 重试失败:`, retryError)
          await this.handleRequestError(symbol, retryError, callback)
        }
      }, this.retryDelay)
    } else {
      console.error(`币种 ${symbol} 达到最大重试次数，请求失败`)
      this.requestStatus.set(symbol, 'failed')
    }
  }

  /**
   * 批量获取多个币价格
   * @param {Array} symbols 币种符号数组
   * @param {Function} callback 价格更新回调函数
   * @returns {Promise} 返回Promise对象
   */
  async getMultipleSpontaneousCoinPrices(symbols, callback) {
    console.log(`开始批量获取币种价格:`, symbols)
    
    const promises = symbols.map(symbol => 
      this.getSpontaneousCoinPrice(symbol, callback).catch(error => {
        console.error(`币种 ${symbol} 获取失败:`, error)
        return null
      })
    )
    
    try {
      const results = await Promise.allSettled(promises)
      const successCount = results.filter(result => result.status === 'fulfilled').length
      console.log(`批量获取完成: ${successCount}/${symbols.length} 个币种成功`)
      return results
    } catch (error) {
      console.error('批量获取币种价格失败:', error)
      throw error
    }
  }

  /**
   * 清除币种请求状态
   * @param {string} symbol 币种符号
   */
  clearRequestStatus(symbol) {
    this.requestStatus.delete(symbol)
    this.retryCount.delete(symbol)
    console.log(`清除币种 ${symbol} 请求状态`)
  }

  /**
   * 清除所有请求状态
   */
  clearAllRequestStatus() {
    this.requestStatus.clear()
    this.retryCount.clear()
    console.log('清除所有请求状态')
  }

  /**
   * 获取币种价格
   * @param {string} symbol 币种符号
   * @param {Function} callback 回调函数
   */
  async fetchSpontaneousCoinPrice(symbol, callback) {
    try {
      // 调用后端API获取币种价格
      const response = await get(`/api/spontaneous/price/${symbol}`)
      
      if (response && response.code === 200) {
        const priceData = response.data
        
        // 调用回调函数更新价格
        if (callback && typeof callback === 'function') {
          callback(priceData)
        }
        
        return priceData
      } else {
        throw new Error(`API响应错误: ${response?.message || '未知错误'}`)
      }
    } catch (error) {
      console.error(`获取币种 ${symbol} 价格失败:`, error)
      throw error
    }
  }

  /**
   * 检查币种请求状态
   * @param {string} symbol 币种符号
   * @returns {string} 请求状态
   */
  getRequestStatus(symbol) {
    return this.requestStatus.get(symbol) || 'idle'
  }

  /**
   * 检查是否正在请求
   * @param {string} symbol 币种符号
   * @returns {boolean}
   */
  isRequesting(symbol) {
    return this.requestStatus.get(symbol) === 'loading'
  }

  /**
   * 获取所有请求状态
   * @returns {Object}
   */
  getAllRequestStatus() {
    const status = {}
    this.requestStatus.forEach((value, key) => {
      status[key] = value
    })
    return status
  }
}

// 创建单例实例
const spontaneousCoinService = new SpontaneousCoinService()

export default spontaneousCoinService
